package main
import (
	"fmt"
	"sort"
	"math/rand"
)
//接口的经典案例

func main(){
	//1、冒泡排序  2、系统的排序方法
	//先定义一个数组/切片
	var intSlice = []int{1,0,-1,22,92}
	//对该intSlice进行排序 
	//2、
	sort.Ints(intSlice)  //由于切片式引用类型，所以会更改主函数的排序
	fmt.Println("Slice : ",intSlice)

	//对结构体切片进行排序
	//2、Sort包有一个Sort方法，接收一个接口
	/*
	type Interface interface {
    	// Len方法返回集合中的元素个数
    	Len() int
    	// Less方法报告索引i的元素是否比索引j的元素小
    	Less(i, j int) bool
    	// Swap方法交换索引i和j的两个元素
    	Swap(i, j int)
	}
	*/
	Heros := HeroSlice{{"A",11},{"B",100},{"C",31},{"D",8}}
	fmt.Println("Heros : ",Heros)
	sort.Sort(Heros) //调用sort包的Sort方法 ： Sort(data Interface)  传入实现Interface接口的类型，该类型是自定义切片类型！
	fmt.Println("Heros : ",Heros)
	

	i := 10
	j := 20
	i , j = j , i
	fmt.Println("i = ",i,"  j = ",j)

	var Students StuSlice
	for i := 0; i < 10;i++{
		stu := Student{
			Name : fmt.Sprintf("Student%d",rand.Intn(100)),
			Score : float64(rand.Intn(100)),
		}
		Students = append(Students,stu)
	}
	fmt.Println("Students : ",Students)
	sort.Sort(Students)
	fmt.Println("Students : ",Students)
	
}





//对结构体切片进行排序三步走
//1、声明一个Hero结构体
type Hero struct{
	Name string
	Age int
}
//2、声明Hero结构体切片类型
type HeroSlice []Hero
//3、实现Interface接口
func (hs HeroSlice) Len() int{
	return len(hs)
}
func (hs HeroSlice) Less(i,j int)bool{ //按照什么情况排序
	return hs[i].Age < hs[j].Age
}
func (hs HeroSlice) Swap(i,j int){
	temp := hs[i]
	hs[i] = hs[j]
	hs[j] = temp
	//交换的简易写法  ：  hs[i],hs[j] = hs[j],hs[i]
}



type Student struct{
	Name string
	Score float64
}
type StuSlice []Student
func (ss StuSlice)Len()int{
	return len(ss)
}
func (ss StuSlice)Less(i,j int)bool{
	return ss[i].Score > ss[j].Score
}
func (ss StuSlice)Swap(i,j int){
	ss[i],ss[j] = ss[j],ss[i]
}